{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|default_exp calibration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calibration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">Functionality to calibrate a trained, binary classification model using temperature scaling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "from tsai.imports import *\n",
    "from sklearn.calibration import calibration_curve\n",
    "from tsai.data.core import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class ModelWithTemperature(nn.Module):\n",
    "    \"\"\" A decorator which wraps a model with temperature scaling \"\"\"\n",
    "\n",
    "    def __init__(self, model):\n",
    "        super().__init__()\n",
    "        self.model = model\n",
    "        self.temperature = nn.Parameter(torch.ones(1,1))\n",
    "\n",
    "    def forward(self, input):\n",
    "        logits = self.model(input)\n",
    "        return self.temperature_scale(logits)\n",
    "\n",
    "    def temperature_scale(self, logits):\n",
    "        temperature = self.temperature.expand(logits.size(0), logits.size(1)).to(logits.device)\n",
    "        return torch.div(logits, temperature)\n",
    "\n",
    "\n",
    "class TemperatureSetter(nn.Module):\n",
    "    \"\"\" Calibrates a binary classification model optimizing temperature \"\"\"\n",
    "\n",
    "    def __init__(self, model, lr=0.01, max_iter=1_000, line_search_fn=None, n_bins=10, verbose=True):\n",
    "        super().__init__()\n",
    "        self.model = ModelWithTemperature(model) if not hasattr(model, 'temperature_scale') else model\n",
    "        self.lr, self.max_iter, self.line_search_fn, self.n_bins, self.verbose = lr, max_iter, line_search_fn, n_bins, verbose\n",
    "        self.nll_criterion = CrossEntropyLossFlat()\n",
    "        self.ece_criterion = ECELoss(n_bins)\n",
    "\n",
    "    def forward(self, dl):\n",
    "        logits_list = []\n",
    "        labels_list = []\n",
    "        with torch.no_grad():\n",
    "            for input, label in dl:\n",
    "                logits = self.model(input)\n",
    "                logits_list.append(logits)\n",
    "                labels_list.append(label)\n",
    "            logits = torch.cat(logits_list)\n",
    "            labels = torch.cat(labels_list)\n",
    "\n",
    "        if self.verbose:\n",
    "            before_temperature_nll = self.nll_criterion(logits, labels).item()\n",
    "            before_temperature_ece = self.ece_criterion(logits, labels).item()\n",
    "            print(f'Before temperature - NLL: {before_temperature_nll:.3f}, ECE: {before_temperature_ece:.3f}')\n",
    "\n",
    "        optimizer = torch.optim.LBFGS([self.model.temperature], lr=self.lr, max_iter=self.max_iter, line_search_fn=self.line_search_fn)\n",
    "\n",
    "        def _evaluation():\n",
    "            optimizer.zero_grad()\n",
    "            loss = self.nll_criterion(self.model.temperature_scale(logits), labels)\n",
    "            loss.backward()\n",
    "            return loss\n",
    "\n",
    "        pv('Calibrating the model...', self.verbose)\n",
    "        optimizer.step(_evaluation)\n",
    "        pv('...model calibrated', self.verbose)\n",
    "\n",
    "        if self.verbose:\n",
    "            after_temperature_nll = self.nll_criterion(self.model.temperature_scale(logits), labels).item()\n",
    "            after_temperature_ece = self.ece_criterion(self.model.temperature_scale(logits), labels).item()\n",
    "            print(f'Optimal temperature: {self.model.temperature.item():.3f}')\n",
    "            print(f'After temperature  - NLL: {after_temperature_nll:.3f}, ECE: {after_temperature_ece:.3f}\\n')\n",
    "\n",
    "        self.logits = logits\n",
    "        self.scaled_logits = self.model.temperature_scale(logits)\n",
    "        self.labels = labels\n",
    "        self.calibrated_model = self.model\n",
    "        return self.calibrated_model\n",
    "\n",
    "\n",
    "class ECELoss(nn.Module):\n",
    "    \"\"\"Calculates the Expected Calibration Error of a model.\"\"\"\n",
    "    def __init__(self, n_bins=10):\n",
    "        super().__init__()\n",
    "        bin_boundaries = torch.linspace(0, 1, n_bins + 1)\n",
    "        self.bin_lowers = bin_boundaries[:-1]\n",
    "        self.bin_uppers = bin_boundaries[1:]\n",
    "\n",
    "    def forward(self, logits, labels):\n",
    "        softmaxes = F.softmax(logits, dim=1)\n",
    "        confidences, predictions = torch.max(softmaxes, 1)\n",
    "        if isinstance(softmaxes, TSTensor):\n",
    "            confidences, predictions = confidences.data, predictions.data\n",
    "        accuracies = torch.eq(predictions.data, labels)\n",
    "\n",
    "        ece = torch.zeros(1, device=logits.device)\n",
    "        for bin_lower, bin_upper in zip(self.bin_lowers, self.bin_uppers):\n",
    "            # Calculated |confidence - accuracy| in each bin\n",
    "            in_bin = confidences.gt(bin_lower.item()) * confidences.le(bin_upper.item())\n",
    "            prop_in_bin = in_bin.float().mean()\n",
    "            if prop_in_bin.item() > 0:\n",
    "                accuracy_in_bin = accuracies[in_bin].float().mean()\n",
    "                avg_confidence_in_bin = confidences[in_bin].mean()\n",
    "                ece += torch.abs(avg_confidence_in_bin - accuracy_in_bin) * prop_in_bin\n",
    "        return ece"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def plot_calibration_curve(labels, logits, cal_logits=None, figsize=(6,6), n_bins=10, strategy='uniform'):\n",
    "    y_true = labels.cpu().numpy()\n",
    "    pos_probas = F.softmax(logits, dim=1)[:, 1].detach().cpu().numpy()\n",
    "    nn_y, nn_x = calibration_curve(y_true, pos_probas, n_bins=n_bins, strategy=strategy)\n",
    "    fig, ax = plt.subplots(figsize=figsize)\n",
    "    fig.suptitle(\"Calibration plot\", fontsize=16)\n",
    "    ax.plot(nn_x, nn_y, marker=\"o\", linewidth=1, color='orange', label='probas')\n",
    "    if cal_logits is not None:\n",
    "        pos_cal_probas = F.softmax(cal_logits, dim=1)[:, 1].detach().cpu().numpy()\n",
    "        cal_nn_y, cal_nn_x = calibration_curve(y_true, pos_cal_probas, n_bins=n_bins, strategy=strategy)\n",
    "        ax.plot(cal_nn_x, cal_nn_y, marker=\"o\", linewidth=1, color='purple', label='calibrated probas')\n",
    "    ax.plot([0, 1], [0, 1], transform=ax.transAxes, color='gray', lw=1)\n",
    "    ax.set_xlabel(\"Predicted probability\", fontsize=12)\n",
    "    ax.set_ylabel(\"True probability in each bin\", fontsize=12)\n",
    "    ax.set_xticks(np.linspace(0,1,11))\n",
    "    ax.set_yticks(np.linspace(0,1,11))\n",
    "    ax.set_xlim(0,1)\n",
    "    ax.set_ylim(0,1)\n",
    "    initial_ECE = ECELoss(n_bins)(logits, labels).item()\n",
    "    if cal_logits is not None:\n",
    "        final_ECE = ECELoss(n_bins)(cal_logits, labels).item()\n",
    "        title = f\"initial ECE: {initial_ECE:.3f} - final ECE: {final_ECE:.3f}\"\n",
    "    else:\n",
    "        title = f\"ECE: {initial_ECE:.3f}\"\n",
    "    plt.title(title)\n",
    "    plt.legend(loc='best')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "@patch\n",
    "def calibrate_model(self:Learner, X=None, y=None, lr=1e-2, max_iter=10_000, line_search_fn=None, n_bins=10, strategy='uniform',\n",
    "                    show_plot=True, figsize=(6,6), verbose=True):\n",
    "    if X is not None and y is not None:\n",
    "        dl = self.dls.valid.new_dl(X, y)\n",
    "    else:\n",
    "        dl = self.dls.valid\n",
    "    assert dl.c == 2, \"calibrate_model is only available for binary classification tasks\"\n",
    "    temp_setter = TemperatureSetter(self.model, lr=lr, max_iter=max_iter, line_search_fn=line_search_fn, n_bins=n_bins, verbose=verbose)\n",
    "    self.calibrated_model = temp_setter(dl)\n",
    "    if show_plot:\n",
    "        plot_calibration_curve(temp_setter.labels, temp_setter.logits, temp_setter.scaled_logits, n_bins=n_bins, strategy=strategy, figsize=figsize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tsai.basics import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.794469</td>\n",
       "      <td>0.731429</td>\n",
       "      <td>0.500000</td>\n",
       "      <td>00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.758404</td>\n",
       "      <td>0.716087</td>\n",
       "      <td>0.490000</td>\n",
       "      <td>00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X, y, splits = get_UCR_data('FingerMovements', split_data=False)\n",
    "tfms  = [None, TSClassification()]\n",
    "batch_tfms = TSRobustScale()\n",
    "# dls = get_ts_dls(X, y, splits=splits, tfms=tfms, batch_tfms=batch_tfms)\n",
    "learn = TSClassifier(X, y, splits=splits, tfms=tfms, batch_tfms=batch_tfms,\n",
    "                     arch='FCNPlus', metrics=accuracy)\n",
    "learn.fit_one_cycle(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before temperature - NLL: 0.716, ECE: 0.093\n",
      "Calibrating the model...\n",
      "...model calibrated\n",
      "Optimal temperature: 272.026\n",
      "After temperature  - NLL: 0.693, ECE: 0.010\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.calibrate_model()\n",
    "calibrated_model = learn.calibrated_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": "IPython.notebook.save_checkpoint();",
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/nacho/notebooks/tsai/nbs/021_calibration.ipynb saved at 2025-03-01 15:30:57\n",
      "Correct notebook to script conversion! 😃\n",
      "Saturday 01/03/25 15:31:00 CET\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "                <audio  controls=\"controls\" autoplay=\"autoplay\">\n",
       "                    <source src=\"data:audio/wav;base64,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\" type=\"audio/wav\" />\n",
       "                    Your browser does not support the audio element.\n",
       "                </audio>\n",
       "              "
      ],
      "text/plain": [
       "<IPython.lib.display.Audio object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#|eval: false\n",
    "#|hide\n",
    "from tsai.export import get_nb_name; nb_name = get_nb_name(locals())\n",
    "from tsai.imports import create_scripts; create_scripts(nb_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
